package scau.markmapscau.Model.Tool;

import java.awt.*;
import java.io.*;
import java.nio.file.OpenOption;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Locale;
import java.util.Optional;
import javafx.scene.control.Alert;
import javafx.event.ActionEvent;
import javafx.embed.swing.SwingFXUtils;
import javafx.scene.SnapshotParameters;
import javafx.scene.control.ButtonType;
import javafx.scene.image.WritableImage;
import javafx.scene.layout.AnchorPane;
import javafx.stage.FileChooser;
import javafx.stage.Stage;
import scau.markmapscau.LaunchMain;
import scau.markmapscau.View.ViewerArranger;
import scau.markmapscau.Model.Node.Node;
import scau.markmapscau.Model.Node.NodeArranger;
import javax.imageio.ImageIO;
import javax.swing.*;


public class ToolArranger implements Serializable{
    //打开桌面路径
    private final Desktop desktop = Desktop.getDesktop();

    Tool tool = new Tool();
    private String fileName = "";
    private String filePath = "";//当前打开文件的路径

    public void setFileName(String fileName){
        this.fileName = fileName;
    }

    public String getFileName(){
        return this.fileName;
    }

    public void setFilePath(String filePath){
        this.filePath=filePath;
    }

    public String getFilePath(){
        return this.filePath;
    }

    /*导出为.jpg或者png图像保存到本地*/
    public File exportPicture(){
        //选定保存路径,返回
        Stage exportStage = new Stage();
        FileChooser fileChooser = new FileChooser();
        fileChooser.setTitle("Export As Image");
        fileChooser.getExtensionFilters().addAll(
                new FileChooser.ExtensionFilter("JPG","*.jpg"),
                new FileChooser.ExtensionFilter("PNG","*.png")
        );
        File exportFileChooser = fileChooser.showSaveDialog(exportStage);
        if (exportFileChooser == null) {
            //当没有选择文件时，提示“未选择文件”,如果确认则返回，取消则重选
            Alert noChooseInfo = new Alert(Alert.AlertType.INFORMATION, "未选择导出路径!");
            noChooseInfo.setTitle("导出");
            noChooseInfo.showAndWait();
            return null;
        }
//        String exportFilePath = exportFileChooser.getAbsolutePath();
//        System.out.println(exportFilePath);
        return exportFileChooser;
    }

    /*保存思维导图文件*/
    public void saveFile(NodeArranger nodeArranger) {
        /*
        1.先读取nodeList(所有结点的所有信息)
        2.把读取到的信息写进一个可自定义后缀的文件
        * */
        if(nodeArranger.getNodeList().size() == 0){
            Alert alert = new Alert(Alert.AlertType.WARNING,"当前绘图区是空的！");
            alert.showAndWait();
            return ;
        }
        //已经保存过或者打开的文件，再次修改后（更新）,可直接保存,不用选文件保存地址，或者再另存
        if(tool.getIsSave()==1 && tool.getIsExit()==1){
            Alert fileSaveSame = new Alert(Alert.AlertType.CONFIRMATION,"是否另存为新的思维导图？");
            fileSaveSame.setTitle("提示");
            fileSaveSame.setHeaderText("思维导图已保存");
            Optional<ButtonType> choice = fileSaveSame.showAndWait();
            if(choice.isPresent() && choice.get() == ButtonType.CANCEL){
                File fileSaveChooser = new File(this.getFilePath());
                saveDirectly(nodeArranger,fileSaveChooser);
                return ;
            }
        }
        Stage saveStage = new Stage();
        FileChooser fileChooser = new FileChooser();
        fileChooser.setTitle("Save the MindMap As a File");
        //后缀名过滤器
        fileChooser.getExtensionFilters().addAll(
                new FileChooser.ExtensionFilter("All files","*.*"),
                new FileChooser.ExtensionFilter("TXT files(*.txt)","*.txt"),
                new FileChooser.ExtensionFilter("XML files(*.xml)","*.xml"),
                new FileChooser.ExtensionFilter("自定义类型(*.自定义)","*.")
        );
        //自定义后缀名
        //思路:先获取输入的文件名称,读取"."之后的输入当作endsName，然后取路径后再加入endsName
        //然而其实已经自动实现了
//        System.out.println(fileChooser.getSelectedExtensionFilter())
        File fileSaveChooser = fileChooser.showSaveDialog(saveStage);
        if(fileSaveChooser != null){
            this.setFileName(fileSaveChooser.getName());
            this.setFilePath(fileSaveChooser.getAbsolutePath());
        }else{
            return ;
        }
//        String fileEndsName = fileSaveChooser.getName().endsWith();
//        System.out.println(fileEndsName);
//        System.out.println(fileSaveChooser);

        if(fileSaveChooser.exists()){
            //当文件以存在时，则覆盖保存
            Alert fileExitInfo = new Alert(Alert.AlertType.CONFIRMATION,"该文件已存在，是否覆盖保存？");
            fileExitInfo.setTitle("文件存在");
            Optional<ButtonType> choice = fileExitInfo.showAndWait();
            if(choice.isPresent() && choice.get() == ButtonType.OK){
                saveDirectly(nodeArranger,fileSaveChooser);
            }
        }else {
            //保存
            saveDirectly(nodeArranger,fileSaveChooser);
        }
    }

    public void saveDirectly(NodeArranger nodeArranger,File fileSaveChooser){
        try {
//           String saveFilePath = fileSaveChooser.getAbsolutePath();
//           System.out.println("保存文件的路径"+saveFilePath);
            //根据要保存的文件创建对象输出流，序列化输出
            FileOutputStream fileOutputStream = new FileOutputStream(fileSaveChooser);
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
            //将容器里所绘制的利用对象全部写入选中的文件中
            //注意：终端输出没问题，但是用IDEA保存用UTF-8在.txt是以二进制编码输出，所以打开文件会出现乱码
            //System.out.println(nodeList.values());
            objectOutputStream.writeObject(nodeArranger);
            //一个一个结点信息地保存进去
//                for(Node node:nodeList.values()){
//                    System.out.println(node);
//                    objectOutputStream.writeObject(node);
//                }
//            ;
            //设置为已保存，打开文件时就不用再问了
            //实时保存替换时之后思维导图的背景颜色
            ViewerArranger viewerArranger = LaunchMain.viewerArranger;
            String backColor = viewerArranger.nodeArranger.getBackColor();
            viewerArranger.nodeArranger.setBackColor(backColor);

            tool.setIsSave(1);
            tool.setIsExit(1);
            System.out.println(tool.getIsSave());
            Alert saveSucInfo = new Alert(Alert.AlertType.INFORMATION,"保存成功！");
            saveSucInfo.setTitle("保存文件");
            saveSucInfo.showAndWait();
            objectOutputStream.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (Exception e){
            e.printStackTrace();
        }
    }

    /*打开思维导图文件*/
    public NodeArranger openFile() {
       /*其实一共就做两件事：
        1.获取打开路径
        2.判断当前面板是否有思维导图
        3.根据nodeList的信息画出每一个结点
       */
        ViewerArranger viewerArranger = LaunchMain.viewerArranger;
        NodeArranger nodeArranger = viewerArranger.nodeArranger;
        //LinkedHashMap nodeList = viewerArranger.nodeArranger.getNodeList();
//        System.out.println(nodeList);

        //当第一次打开每次都打开前都没保存时就问
        if((nodeArranger.getNodeList().size() != 0) && (tool.getIsSave() == 0 || tool.getIsExit() == 0)){
            Alert saveORInfo = new Alert(Alert.AlertType.CONFIRMATION,"是否保存当前已有思维导图");
            saveORInfo.setTitle("当前思维导图未保存");
            Optional<ButtonType> choice = saveORInfo.showAndWait();
            if(choice.isPresent() && choice.get()==ButtonType.OK ){
                //获取当前链表信息，再调用本类的saveFile()
                tool.setIsSave(1); ;
                tool.setIsExit(1);     //保存过了
                //拿到当前绘图区的信息
//                System.out.println(nodeList);
                saveFile(nodeArranger);
            }
            //当选择取消时，即不保存当前绘图区，直接打开
            tool.setIsSave(1);
        }
        /*
         isExit是对于是否要询问再次保存，只有保存过，即isExit=1才不再问，否则一直问
          isSave == 1 一直打开
         */
        if( nodeArranger.getNodeList().size() == 0|| tool.getIsSave() == 1){
            //清空绘图区里的东西,或直接在controller实现
//            ViewerArranger viewerArranger = LaunchMain.viewerArranger;
//            viewerArranger.cleanAnchorPane();
            try {
                Stage openStage = new Stage();
                FileChooser fileChooser = new FileChooser();

                fileChooser.setTitle("Open a MindMap");
                FileChooser.ExtensionFilter extFilter = new FileChooser.ExtensionFilter("All files","*.*");
                fileChooser.getExtensionFilters().add(extFilter);
                File fileOpenChooser = fileChooser.showOpenDialog(openStage);
                if (fileOpenChooser == null) {
                    //可改为重新选择，方式如上有,并要再写一个直接打开的，跳过询问当前保存
                    Alert openNullInfo = new Alert(Alert.AlertType.INFORMATION,"没有选中任何文件！");
                    openNullInfo.setTitle("选择打开文件");
                    openNullInfo.showAndWait();
                    //返回现在绘图区的哈希表信息
                    return nodeArranger;
                } else {
                    String name = fileOpenChooser.getName();
                    this.setFileName(name);
                    this.setFilePath(fileOpenChooser.getAbsolutePath());
                    System.out.println(fileOpenChooser.getAbsolutePath());
                    System.out.println(fileOpenChooser.getName());
                    System.out.println(fileOpenChooser);
                    //看一下打开的文件路径
//                    String fileOpenPath = fileOpenChooser.getAbsolutePath();
//                    System.out.println("打开文件的路径"+fileOpenPath);
                    FileInputStream fileInputStream = new FileInputStream(fileOpenChooser);
                    ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
                    //将选中的文件读出来，更新转换为哈希表信息，实现接受信息
                    nodeArranger = (NodeArranger)objectInputStream.readObject();
                    System.out.println(nodeArranger);
                    //遍历文件里面的结点信息，将每一节点信息取出来保存
//                    for(int i=0;i< nodeList.size();i++) {
//                        Node node = (Node)nodeList.get(i);
//                        ViewerArranger drawNode = LaunchMain.viewerArranger;
//                        drawNode.newNodeByParent(node.getId());
                    //输出看看有没有读取成功每一个结点信息
//                        System.out.println(node);
//                    }
                    objectInputStream.close();
                    //打开成功可不需要提示
                    //一般来说，能打开的文件都是保存过的,所以下次打开时就不用问是否保存
                    tool.setIsSave(1);
                    tool.setIsExit(1);
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        return nodeArranger;
    }
}